---
layout: "default"
title: "ArraySlice"
description: "Swift documentation for 'ArraySlice': The Array-like type that represents a sub-sequence of any."
keywords: "ArraySlice,struct,swift,documentation,append,extend,filter,flatMap,generate,getMirror,insert,join,map,reduce,removeAll,removeAtIndex,removeLast,removeRange,replaceRange,reserveCapacity,reverse,sort,sorted,splice,withUnsafeBufferPointer,withUnsafeMutableBufferPointer,capacity,count,debugDescription,description,endIndex,first,isEmpty,last,startIndex,Element,SubSlice,Generator,Index,SubSequence"
root: "/v1.2"
---

<div class="intro-declaration"><code class="language-swift">struct ArraySlice&lt;T&gt;</code></div>

<div class="discussion comment">
    <p>The <code>Array</code>-like type that represents a sub-sequence of any
<code>Array</code>, <code>ContiguousArray</code>, or other <code>ArraySlice</code>.</p>

<p><code>ArraySlice</code> always uses contiguous storage and does not bridge to
Objective-C.</p>

<p><strong>Warning:</strong> Long-term storage of <code>ArraySlice</code> instances is discouraged</p>

<p>   Because a <code>ArraySlice</code> presents a <em>view</em> onto the storage of some
   larger array even after the original array&#39;s lifetime ends,
   storing the slice may prolong the lifetime of elements that are
   no longer accessible, which can manifest as apparent memory and
   object leakage.  To prevent this effect, use <code>ArraySlice</code> only for
   transient computation.</p>
</div>

<table class="standard">
<tr>
<th id="inheritance">Inheritance</th>
<td>
<code class="inherits">ArrayLiteralConvertible, CollectionType, DebugPrintable, ExtensibleCollectionType, MutableCollectionType, MutableSliceable, Printable, RangeReplaceableCollectionType, Reflectable, SequenceType, Sliceable, _ArrayType, _CollectionType, _DestructorSafeContainer, _ExtensibleCollectionType, _SequenceType, _Sequence_Type, _Sliceable, __ArrayType</code>
<span class="viz"><a href="hierarchy/">View Protocol Hierarchy &rarr;</a></span>
</td>
</tr>

<tr>
<th id="aliases">Associated Types</th>
<td>
<span id="aliasesmark"></span>
<div class="declaration">
<code class="language-swift">Element = T</code>
<div class="comment">
    <p>The type of element stored by this <code>ArraySlice</code></p>
</div>
</div>
<div class="declaration">
<code class="language-swift">SubSlice = ArraySlice&lt;T&gt;</code>
<div class="comment">
    <p>A type that can represent a sub-range of an <code>ArraySlice</code> </p>
</div>
</div>
<div class="declaration">
<code class="language-swift">Generator = IndexingGenerator&lt;ArraySlice&lt;T&gt;&gt;</code>
<div class="comment">
    <p><em>Type alias inferred.</em></p>
</div>
</div>
<div class="declaration">
<code class="language-swift">Index = Int</code>
<div class="comment">
    <p><em>Type alias inferred.</em></p>
</div>
</div>
<div class="declaration">
<code class="language-swift">SubSequence = ArraySlice&lt;T&gt;</code>
<div class="comment">
    <p><em>Type alias inferred.</em></p>
</div>
</div>
</td>
</tr>


<tr>
<th>Import</th>
<td><code class="language-swift">import Swift</code></td>
</tr>

</table>


<h3>Initializers</h3>
<div class="declaration" id="init">
<a class="toggle-link" data-toggle="collapse" href="#comment-init">init()</a><div class="comment collapse" id="comment-init"><div class="p">
    <p>Construct an empty ArraySlice</p>

    <h4>Declaration</h4>    
    <code class="language-swift">init()</code>

    </div></div>
</div>
<div class="declaration" id="init_-slicebuffer-t">
<a class="toggle-link" data-toggle="collapse" href="#comment-init_-slicebuffer-t">init(<wbr>_: _SliceBuffer&lt;T&gt;)</a><div class="comment collapse" id="comment-init_-slicebuffer-t"><div class="p">
    <p>Initialization from an existing buffer does not have &quot;array.init&quot;
semantics because the caller may retain an alias to buffer.</p>

    <h4>Declaration</h4>    
    <code class="language-swift">init(_ buffer: _SliceBuffer&lt;T&gt;)</code>

    </div></div>
</div>
<div class="declaration" id="init-s_-sequencetype-where-t-t_-s">
<a class="toggle-link" data-toggle="collapse" href="#comment-init-s_-sequencetype-where-t-t_-s"><wbr>init&lt;S : SequenceType where T == T&gt;(<wbr>_: S)</a><div class="comment collapse" id="comment-init-s_-sequencetype-where-t-t_-s"><div class="p">
    <p>Construct from an arbitrary sequence with elements of type <code>T</code></p>

    <h4>Declaration</h4>    
    <code class="language-swift">init&lt;S : SequenceType where T == T&gt;(_ s: S)</code>

    </div></div>
</div>
<div class="declaration" id="init-arrayliteral_">
<a class="toggle-link" data-toggle="collapse" href="#comment-init-arrayliteral_">init(<wbr>arrayLiteral:)</a><div class="comment collapse" id="comment-init-arrayliteral_"><div class="p">
    <p>Create an instance containing <code>elements</code>.</p>

    <h4>Declaration</h4>    
    <code class="language-swift">init(arrayLiteral elements: T...)</code>

    </div></div>
</div>
<div class="declaration" id="init-count_repeatedvalue_">
<a class="toggle-link" data-toggle="collapse" href="#comment-init-count_repeatedvalue_">init(<wbr>count:<wbr>repeatedValue:)</a><div class="comment collapse" id="comment-init-count_repeatedvalue_"><div class="p">
    <p>Construct a ArraySlice of <code>count</code> elements, each initialized to
<code>repeatedValue</code>.</p>

    <h4>Declaration</h4>    
    <code class="language-swift">init(count: Int, repeatedValue: T)</code>

    </div></div>
</div>


<h3>Instance Variables</h3>
<div class="declaration" id="var-capacity_-int">
<a class="toggle-link" data-toggle="collapse" href="#comment-var-capacity_-int">var capacity: Int</a><div class="comment collapse" id="comment-var-capacity_-int"><div class="p">
    <p>How many elements the <code>ArraySlice</code> can store without reallocation</p>

    <h4>Declaration</h4>    
    <code class="language-swift">var capacity: Int { get }</code>

    </div></div>
</div>
<div class="declaration" id="var-count_-int">
<a class="toggle-link" data-toggle="collapse" href="#comment-var-count_-int">var count: Int</a><div class="comment collapse" id="comment-var-count_-int"><div class="p">
    <p>How many elements the ArraySlice stores</p>

    <h4>Declaration</h4>    
    <code class="language-swift">var count: Int { get }</code>

    </div></div>
</div>
<div class="declaration" id="var-debugdescription_-string">
<a class="toggle-link" data-toggle="collapse" href="#comment-var-debugdescription_-string">var debugDescription: String</a><div class="comment collapse" id="comment-var-debugdescription_-string"><div class="p">
    <p>A textual representation of <code>self</code>, suitable for debugging.</p>

    <h4>Declaration</h4>    
    <code class="language-swift">var debugDescription: String { get }</code>

    </div></div>
</div>
<div class="declaration" id="var-description_-string">
<a class="toggle-link" data-toggle="collapse" href="#comment-var-description_-string">var description: String</a><div class="comment collapse" id="comment-var-description_-string"><div class="p">
    <p>A textual representation of <code>self</code>.</p>

    <h4>Declaration</h4>    
    <code class="language-swift">var description: String { get }</code>

    </div></div>
</div>
<div class="declaration" id="var-endindex_-int">
<a class="toggle-link" data-toggle="collapse" href="#comment-var-endindex_-int">var endIndex: Int</a><div class="comment collapse" id="comment-var-endindex_-int"><div class="p">
    <p>A &quot;past-the-end&quot; element index; the successor of the last valid
subscript argument.</p>

    <h4>Declaration</h4>    
    <code class="language-swift">var endIndex: Int { get }</code>

    </div></div>
</div>
<div class="declaration" id="var-first_-t">
<a class="toggle-link" data-toggle="collapse" href="#comment-var-first_-t">var first: T?</a><div class="comment collapse" id="comment-var-first_-t"><div class="p">
    <p>The first element, or <code>nil</code> if the array is empty</p>

    <h4>Declaration</h4>    
    <code class="language-swift">var first: T? { get }</code>

    </div></div>
</div>
<div class="declaration" id="var-isempty_-bool">
<a class="toggle-link" data-toggle="collapse" href="#comment-var-isempty_-bool">var isEmpty: Bool</a><div class="comment collapse" id="comment-var-isempty_-bool"><div class="p">
    <p><code>true</code> if and only if the <code>ArraySlice</code> is empty</p>

    <h4>Declaration</h4>    
    <code class="language-swift">var isEmpty: Bool { get }</code>

    </div></div>
</div>
<div class="declaration" id="var-last_-t">
<a class="toggle-link" data-toggle="collapse" href="#comment-var-last_-t">var last: T?</a><div class="comment collapse" id="comment-var-last_-t"><div class="p">
    <p>The last element, or <code>nil</code> if the array is empty</p>

    <h4>Declaration</h4>    
    <code class="language-swift">var last: T? { get }</code>

    </div></div>
</div>
<div class="declaration" id="var-startindex_-int">
<a class="toggle-link" data-toggle="collapse" href="#comment-var-startindex_-int">var startIndex: Int</a><div class="comment collapse" id="comment-var-startindex_-int"><div class="p">
    <p>Always zero, which is the index of the first element when non-empty.</p>

    <h4>Declaration</h4>    
    <code class="language-swift">var startIndex: Int { get }</code>

    </div></div>
</div>

<h3>Subscripts</h3>
<div class="declaration" id="subscript-subscript_-int">
<a class="toggle-link" data-toggle="collapse" href="#comment-subscript-subscript_-int">subscript(_: Int)</a>
<div class="comment collapse" id="comment-subscript-subscript_-int"><div class="p">
    

    <h4>Declaration</h4>    
    <code class="language-swift">subscript(index: Int) -&gt; T</code>
    
    
</div></div>
</div>
<div class="declaration" id="subscript-subscript_-range-int">
<a class="toggle-link" data-toggle="collapse" href="#comment-subscript-subscript_-range-int">subscript(_: Range&lt;Int&gt;)</a>
<div class="comment collapse" id="comment-subscript-subscript_-range-int"><div class="p">
    

    <h4>Declaration</h4>    
    <code class="language-swift">subscript(subRange: Range&lt;Int&gt;) -&gt; ArraySlice&lt;T&gt;</code>
    
    
</div></div>
</div>


<h3>Instance Methods</h3>
<div class="declaration" id="func-append_">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-append_">mutating func append(<wbr>_:)</a>
        
<div class="comment collapse" id="comment-func-append_"><div class="p">
    <p>Append newElement to the ArraySlice</p>

<p>Complexity: amortized O(1) unless <code>self</code>&#39;s storage is shared with another live array; O(<code>count</code>) otherwise.</p>

    <h4>Declaration</h4>    
    <code class="language-swift">mutating func append(newElement: T)</code>
    
    
</div></div>
</div>
<div class="declaration" id="func-extend_">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-extend_">mutating func extend(<wbr>_:)</a>
        
<div class="comment collapse" id="comment-func-extend_"><div class="p">
    <p>Append the elements of <code>newElements</code> to <code>self</code>.</p>

<p>Complexity: O(<em>length of result</em>) </p>

    <h4>Declaration</h4>    
    <code class="language-swift">mutating func extend&lt;S : SequenceType where T == T&gt;(newElements: S)</code>
    
    
</div></div>
</div>
<div class="declaration" id="func-filter_">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-filter_">func filter(<wbr>_:)</a>
        
<div class="comment collapse" id="comment-func-filter_"><div class="p">
    <p>Return an <code>ArraySlice</code> containing the elements <code>x</code> of <code>self</code> for which
<code>includeElement(x)</code> is <code>true</code></p>

    <h4>Declaration</h4>    
    <code class="language-swift">func filter(includeElement: (T) -&gt; Bool) -&gt; ArraySlice&lt;T&gt;</code>
    
    
</div></div>
</div>
<div class="declaration" id="func-flatmap_">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-flatmap_">func flatMap(<wbr>_:)</a>
        
<div class="comment collapse" id="comment-func-flatmap_"><div class="p">
    <p>Return an <code>ArraySlice</code> containing the results of calling
<code>transform(x)</code> on each element <code>x</code> of <code>self</code> and flattening the result.</p>

    <h4>Declaration</h4>    
    <code class="language-swift">func flatMap&lt;U&gt;(transform: @noescape (T) -&gt; ArraySlice&lt;U&gt;) -&gt; ArraySlice&lt;U&gt;</code>
    
    
</div></div>
</div>
<div class="declaration" id="func-generate">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-generate">func generate()</a>
        
<div class="comment collapse" id="comment-func-generate"><div class="p">
    <p>Return a <em>generator</em> over the elements.</p>

<p>Complexity: O(1)</p>

    <h4>Declaration</h4>    
    <code class="language-swift">func generate() -&gt; IndexingGenerator&lt;ArraySlice&lt;T&gt;&gt;</code>
    
    
</div></div>
</div>
<div class="declaration" id="func-getmirror">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-getmirror">func getMirror()</a>
        
<div class="comment collapse" id="comment-func-getmirror"><div class="p">
    <p>Returns a mirror that reflects <code>self</code>.</p>

    <h4>Declaration</h4>    
    <code class="language-swift">func getMirror() -&gt; MirrorType</code>
    
    
</div></div>
</div>
<div class="declaration" id="func-insert_atindex_">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-insert_atindex_">mutating func insert(<wbr>_:<wbr>atIndex:)</a>
        
<div class="comment collapse" id="comment-func-insert_atindex_"><div class="p">
    <p>Insert <code>newElement</code> at index <code>i</code>.</p>

<p>Requires: <code>i &lt;= count</code></p>

<p>Complexity: O(<code>count</code>).</p>

    <h4>Declaration</h4>    
    <code class="language-swift">mutating func insert(newElement: T, atIndex i: Int)</code>
    
    
</div></div>
</div>
<div class="declaration" id="func-join_">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-join_">func join(<wbr>_:)</a>
        
<div class="comment collapse" id="comment-func-join_"><div class="p">
    <p>Interpose <code>self</code> between each consecutive pair of <code>elements</code>,
and concatenate the elements of the resulting sequence.  For
example, <code>[-1, -2].join([[1, 2, 3], [4, 5, 6], [7, 8, 9]])</code>
yields <code>[1, 2, 3, -1, -2, 4, 5, 6, -1, -2, 7, 8, 9]</code></p>

    <h4>Declaration</h4>    
    <code class="language-swift">func join&lt;S : SequenceType where ArraySlice&lt;T&gt; == ArraySlice&lt;T&gt;&gt;(elements: S) -&gt; ArraySlice&lt;T&gt;</code>
    
    
</div></div>
</div>
<div class="declaration" id="func-map_">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-map_">func map(<wbr>_:)</a>
        
<div class="comment collapse" id="comment-func-map_"><div class="p">
    <p>Return an <code>ArraySlice</code> containing the results of calling
<code>transform(x)</code> on each element <code>x</code> of <code>self</code></p>

    <h4>Declaration</h4>    
    <code class="language-swift">func map&lt;U&gt;(transform: (T) -&gt; U) -&gt; ArraySlice&lt;U&gt;</code>
    
    
</div></div>
</div>
<div class="declaration" id="func-reduce_combine_">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-reduce_combine_">func reduce(<wbr>_:<wbr>combine:)</a>
        
<div class="comment collapse" id="comment-func-reduce_combine_"><div class="p">
    <p>Return the result of repeatedly calling <code>combine</code> with an
accumulated value initialized to <code>initial</code> and each element of
<code>self</code>, in turn, i.e. return
<code>combine(combine(...combine(combine(initial, self[0]),
self[1]),...self[count-2]), self[count-1])</code>.</p>

    <h4>Declaration</h4>    
    <code class="language-swift">func reduce&lt;U&gt;(initial: U, combine: @noescape (U, T) -&gt; U) -&gt; U</code>
    
    
</div></div>
</div>
<div class="declaration" id="func-removeall_">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-removeall_">mutating func removeAll(<wbr>_:)</a>
        
<div class="comment collapse" id="comment-func-removeall_"><div class="p">
    <p>Remove all elements.</p>

<p>Postcondition: <code>capacity == 0</code> iff <code>keepCapacity</code> is <code>false</code>.</p>

<p>Complexity: O(<code>count(self)</code>).</p>

    <h4>Declaration</h4>    
    <code class="language-swift">mutating func removeAll(keepCapacity: Bool = default)</code>
    
    
</div></div>
</div>
<div class="declaration" id="func-removeatindex_">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-removeatindex_">mutating func removeAtIndex(<wbr>_:)</a>
        
<div class="comment collapse" id="comment-func-removeatindex_"><div class="p">
    <p>Remove and return the element at index <code>i</code></p>

<p>Invalidates all indices with respect to <code>self</code>.</p>

<p>Complexity: O(<code>count</code>).</p>

    <h4>Declaration</h4>    
    <code class="language-swift">mutating func removeAtIndex(index: Int) -&gt; T</code>
    
    
</div></div>
</div>
<div class="declaration" id="func-removelast">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-removelast">mutating func removeLast()</a>
        
<div class="comment collapse" id="comment-func-removelast"><div class="p">
    <p>Remove an element from the end of the ArraySlice in O(1).
Requires: count &gt; 0</p>

    <h4>Declaration</h4>    
    <code class="language-swift">mutating func removeLast() -&gt; T</code>
    
    
</div></div>
</div>
<div class="declaration" id="func-removerange_">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-removerange_">mutating func removeRange(<wbr>_:)</a>
        
<div class="comment collapse" id="comment-func-removerange_"><div class="p">
    <p>Remove the indicated <code>subRange</code> of elements</p>

<p>Complexity: O(<code>count</code>).</p>

    <h4>Declaration</h4>    
    <code class="language-swift">mutating func removeRange(subRange: Range&lt;Int&gt;)</code>
    
    
</div></div>
</div>
<div class="declaration" id="func-replacerange_with_">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-replacerange_with_">mutating func replaceRange(<wbr>_:<wbr>with:)</a>
        
<div class="comment collapse" id="comment-func-replacerange_with_"><div class="p">
    <p>Replace the given <code>subRange</code> of elements with <code>newElements</code>.</p>

<p>Complexity: O(<code>count(subRange)</code>) if <code>subRange.endIndex
== self.endIndex</code> and <code>isEmpty(newElements)</code>, O(N) otherwise.</p>

    <h4>Declaration</h4>    
    <code class="language-swift">mutating func replaceRange&lt;C : CollectionType where T == T&gt;(subRange: Range&lt;Int&gt;, with newElements: C)</code>
    
    
</div></div>
</div>
<div class="declaration" id="func-reservecapacity_">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-reservecapacity_">mutating func reserveCapacity(<wbr>_:)</a>
        
<div class="comment collapse" id="comment-func-reservecapacity_"><div class="p">
    <p>Reserve enough space to store minimumCapacity elements.</p>

<p>PostCondition: <code>capacity &gt;= minimumCapacity</code> and the array has
mutable contiguous storage.</p>

<p>Complexity: O(<code>count</code>)</p>

    <h4>Declaration</h4>    
    <code class="language-swift">mutating func reserveCapacity(minimumCapacity: Int)</code>
    
    
</div></div>
</div>
<div class="declaration" id="func-reverse">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-reverse">func reverse()</a>
        
<div class="comment collapse" id="comment-func-reverse"><div class="p">
    <p>A ArraySlice containing the elements of <code>self</code> in reverse order</p>

    <h4>Declaration</h4>    
    <code class="language-swift">func reverse() -&gt; ArraySlice&lt;T&gt;</code>
    
    
</div></div>
</div>
<div class="declaration" id="func-sort_">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-sort_">mutating func sort(<wbr>_:)</a>
        
<div class="comment collapse" id="comment-func-sort_"><div class="p">
    <p>Sort <code>self</code> in-place according to <code>isOrderedBefore</code>.  Requires:
<code>isOrderedBefore</code> induces a <a href="http://en.wikipedia.org/wiki/Strict_weak_order#Strict_weak_orderings">strict weak ordering</a>
over the elements.</p>

    <h4>Declaration</h4>    
    <code class="language-swift">mutating func sort(isOrderedBefore: (T, T) -&gt; Bool)</code>
    
    
</div></div>
</div>
<div class="declaration" id="func-sorted_">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-sorted_">func sorted(<wbr>_:)</a>
        
<div class="comment collapse" id="comment-func-sorted_"><div class="p">
    <p>Return a copy of <code>self</code> that has been sorted according to
<code>isOrderedBefore</code>.  Requires: <code>isOrderedBefore</code> induces a
<a href="http://en.wikipedia.org/wiki/Strict_weak_order#Strict_weak_orderings">strict weak ordering</a>
over the elements.</p>

    <h4>Declaration</h4>    
    <code class="language-swift">func sorted(isOrderedBefore: (T, T) -&gt; Bool) -&gt; ArraySlice&lt;T&gt;</code>
    
    
</div></div>
</div>
<div class="declaration" id="func-splice_atindex_">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-splice_atindex_">mutating func splice(<wbr>_:<wbr>atIndex:)</a>
        
<div class="comment collapse" id="comment-func-splice_atindex_"><div class="p">
    <p>Insert <code>newElements</code> at index <code>i</code></p>

<p>Invalidates all indices with respect to <code>self</code>.</p>

<p>Complexity: O(<code>count + count(newElements)</code>).</p>

    <h4>Declaration</h4>    
    <code class="language-swift">mutating func splice&lt;S : CollectionType where T == T&gt;(newElements: S, atIndex i: Int)</code>
    
    
</div></div>
</div>
<div class="declaration" id="func-withunsafebufferpointer_">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-withunsafebufferpointer_">func withUnsafeBufferPointer(<wbr>_:)</a>
        
<div class="comment collapse" id="comment-func-withunsafebufferpointer_"><div class="p">
    <p>Call <code>body(p)</code>, where <code>p</code> is a pointer to the <code>ArraySlice</code>&#39;s
contiguous storage.</p>

<p>Often, the optimizer can eliminate bounds checks within an
array algorithm, but when that fails, invoking the
same algorithm on <code>body</code>&#39;s argument lets you trade safety for
speed.</p>

    <h4>Declaration</h4>    
    <code class="language-swift">func withUnsafeBufferPointer&lt;R&gt;(body: @noescape (UnsafeBufferPointer&lt;T&gt;) -&gt; R) -&gt; R</code>
    
    
</div></div>
</div>
<div class="declaration" id="func-withunsafemutablebufferpointer_">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-withunsafemutablebufferpointer_">mutating func withUnsafeMutableBufferPointer(<wbr>_:)</a>
        
<div class="comment collapse" id="comment-func-withunsafemutablebufferpointer_"><div class="p">
    <p>Call <code>body(p)</code>, where <code>p</code> is a pointer to the <code>ArraySlice</code>&#39;s
mutable contiguous storage.</p>

<p>Often, the optimizer can eliminate bounds- and uniqueness-checks
within an array algorithm, but when that fails, invoking the
same algorithm on <code>body</code>&#39;s argument lets you trade safety for
speed.</p>

    <h4>Declaration</h4>    
    <code class="language-swift">mutating func withUnsafeMutableBufferPointer&lt;R&gt;(body: @noescape (inout UnsafeMutableBufferPointer&lt;T&gt;) -&gt; R) -&gt; R</code>
    
    
</div></div>
</div>


